﻿// 通过模板 StringUtil_Partial.tt 自动生成的代码，请勿手工修改！

using System.Globalization;

namespace Viyi.Util
{
    partial class StringUtil
    {
        /// <summary>
        /// 将字符串转换为<c>Nullable&lt;int&gt;</c>类型的值
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <param name="style">源字符串描述数字的样式</param>
        /// <returns><c>int?</c>值。若转换失败返回null。</returns>
        public static int? ToInt32(this string s, NumberStyles style)
        {
            int value;
            return int.TryParse(s, style, NumberFormatInfo.CurrentInfo, out value)
                ? (int?) value
                : null;
        }

        /// <summary>
        /// 将字符串转换为<c>int</c>类型的值
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <param name="style">源字符串描述数字的样式</param>
        /// <param name="defaultValue">用转换失败时返回的默认值</param>
        /// <returns>转换得来的<c>int</c>值。若转换失败返回<c>defaultValue</c></returns>
        public static int ToInt32(this string s, NumberStyles style, int defaultValue)
        {
            int value;
            return int.TryParse(s, style, NumberFormatInfo.CurrentInfo, out value)
                ? value
                : defaultValue;
        }

        /// <summary>
        /// 将字符串转换为<c>Nullable&lt;int&gt;</c>类型的值。
        /// 源字符串会被当作采用十进制描述数值。
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <returns><c>int?</c>值。若转换失败返回null。</returns>
        public static int? ToInt32(this string s)
        {
            int value;
            return int.TryParse(s, out value) ? (int?) value : null;
        }

        /// <summary>
        /// 将字符串转换为<c>int</c>类型的值
        /// 源字符串会被当作采用十进制描述数值。
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <param name="defaultValue">用转换失败时返回的默认值</param>
        /// <returns>转换得来的<c>int</c>值。若转换失败返回<c>defaultValue</c></returns>
        public static int ToInt32(this string s, int defaultValue)
        {
            int value;
            return int.TryParse(s, out value) ? value : defaultValue;
        }
    }
}

namespace Viyi.Util
{
    partial class StringUtil
    {
        /// <summary>
        /// 将字符串转换为<c>Nullable&lt;uint&gt;</c>类型的值
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <param name="style">源字符串描述数字的样式</param>
        /// <returns><c>uint?</c>值。若转换失败返回null。</returns>
        public static uint? ToUInt32(this string s, NumberStyles style)
        {
            uint value;
            return uint.TryParse(s, style, NumberFormatInfo.CurrentInfo, out value)
                ? (uint?) value
                : null;
        }

        /// <summary>
        /// 将字符串转换为<c>uint</c>类型的值
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <param name="style">源字符串描述数字的样式</param>
        /// <param name="defaultValue">用转换失败时返回的默认值</param>
        /// <returns>转换得来的<c>uint</c>值。若转换失败返回<c>defaultValue</c></returns>
        public static uint ToUInt32(this string s, NumberStyles style, uint defaultValue)
        {
            uint value;
            return uint.TryParse(s, style, NumberFormatInfo.CurrentInfo, out value)
                ? value
                : defaultValue;
        }

        /// <summary>
        /// 将字符串转换为<c>Nullable&lt;uint&gt;</c>类型的值。
        /// 源字符串会被当作采用十进制描述数值。
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <returns><c>uint?</c>值。若转换失败返回null。</returns>
        public static uint? ToUInt32(this string s)
        {
            uint value;
            return uint.TryParse(s, out value) ? (uint?) value : null;
        }

        /// <summary>
        /// 将字符串转换为<c>uint</c>类型的值
        /// 源字符串会被当作采用十进制描述数值。
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <param name="defaultValue">用转换失败时返回的默认值</param>
        /// <returns>转换得来的<c>uint</c>值。若转换失败返回<c>defaultValue</c></returns>
        public static uint ToUInt32(this string s, uint defaultValue)
        {
            uint value;
            return uint.TryParse(s, out value) ? value : defaultValue;
        }
    }
}

namespace Viyi.Util
{
    partial class StringUtil
    {
        /// <summary>
        /// 将字符串转换为<c>Nullable&lt;short&gt;</c>类型的值
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <param name="style">源字符串描述数字的样式</param>
        /// <returns><c>short?</c>值。若转换失败返回null。</returns>
        public static short? ToInt16(this string s, NumberStyles style)
        {
            short value;
            return short.TryParse(s, style, NumberFormatInfo.CurrentInfo, out value)
                ? (short?) value
                : null;
        }

        /// <summary>
        /// 将字符串转换为<c>short</c>类型的值
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <param name="style">源字符串描述数字的样式</param>
        /// <param name="defaultValue">用转换失败时返回的默认值</param>
        /// <returns>转换得来的<c>short</c>值。若转换失败返回<c>defaultValue</c></returns>
        public static short ToInt16(this string s, NumberStyles style, short defaultValue)
        {
            short value;
            return short.TryParse(s, style, NumberFormatInfo.CurrentInfo, out value)
                ? value
                : defaultValue;
        }

        /// <summary>
        /// 将字符串转换为<c>Nullable&lt;short&gt;</c>类型的值。
        /// 源字符串会被当作采用十进制描述数值。
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <returns><c>short?</c>值。若转换失败返回null。</returns>
        public static short? ToInt16(this string s)
        {
            short value;
            return short.TryParse(s, out value) ? (short?) value : null;
        }

        /// <summary>
        /// 将字符串转换为<c>short</c>类型的值
        /// 源字符串会被当作采用十进制描述数值。
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <param name="defaultValue">用转换失败时返回的默认值</param>
        /// <returns>转换得来的<c>short</c>值。若转换失败返回<c>defaultValue</c></returns>
        public static short ToInt16(this string s, short defaultValue)
        {
            short value;
            return short.TryParse(s, out value) ? value : defaultValue;
        }
    }
}

namespace Viyi.Util
{
    partial class StringUtil
    {
        /// <summary>
        /// 将字符串转换为<c>Nullable&lt;ushort&gt;</c>类型的值
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <param name="style">源字符串描述数字的样式</param>
        /// <returns><c>ushort?</c>值。若转换失败返回null。</returns>
        public static ushort? ToUInt16(this string s, NumberStyles style)
        {
            ushort value;
            return ushort.TryParse(s, style, NumberFormatInfo.CurrentInfo, out value)
                ? (ushort?) value
                : null;
        }

        /// <summary>
        /// 将字符串转换为<c>ushort</c>类型的值
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <param name="style">源字符串描述数字的样式</param>
        /// <param name="defaultValue">用转换失败时返回的默认值</param>
        /// <returns>转换得来的<c>ushort</c>值。若转换失败返回<c>defaultValue</c></returns>
        public static ushort ToUInt16(this string s, NumberStyles style, ushort defaultValue)
        {
            ushort value;
            return ushort.TryParse(s, style, NumberFormatInfo.CurrentInfo, out value)
                ? value
                : defaultValue;
        }

        /// <summary>
        /// 将字符串转换为<c>Nullable&lt;ushort&gt;</c>类型的值。
        /// 源字符串会被当作采用十进制描述数值。
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <returns><c>ushort?</c>值。若转换失败返回null。</returns>
        public static ushort? ToUInt16(this string s)
        {
            ushort value;
            return ushort.TryParse(s, out value) ? (ushort?) value : null;
        }

        /// <summary>
        /// 将字符串转换为<c>ushort</c>类型的值
        /// 源字符串会被当作采用十进制描述数值。
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <param name="defaultValue">用转换失败时返回的默认值</param>
        /// <returns>转换得来的<c>ushort</c>值。若转换失败返回<c>defaultValue</c></returns>
        public static ushort ToUInt16(this string s, ushort defaultValue)
        {
            ushort value;
            return ushort.TryParse(s, out value) ? value : defaultValue;
        }
    }
}

namespace Viyi.Util
{
    partial class StringUtil
    {
        /// <summary>
        /// 将字符串转换为<c>Nullable&lt;long&gt;</c>类型的值
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <param name="style">源字符串描述数字的样式</param>
        /// <returns><c>long?</c>值。若转换失败返回null。</returns>
        public static long? ToInt64(this string s, NumberStyles style)
        {
            long value;
            return long.TryParse(s, style, NumberFormatInfo.CurrentInfo, out value)
                ? (long?) value
                : null;
        }

        /// <summary>
        /// 将字符串转换为<c>long</c>类型的值
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <param name="style">源字符串描述数字的样式</param>
        /// <param name="defaultValue">用转换失败时返回的默认值</param>
        /// <returns>转换得来的<c>long</c>值。若转换失败返回<c>defaultValue</c></returns>
        public static long ToInt64(this string s, NumberStyles style, long defaultValue)
        {
            long value;
            return long.TryParse(s, style, NumberFormatInfo.CurrentInfo, out value)
                ? value
                : defaultValue;
        }

        /// <summary>
        /// 将字符串转换为<c>Nullable&lt;long&gt;</c>类型的值。
        /// 源字符串会被当作采用十进制描述数值。
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <returns><c>long?</c>值。若转换失败返回null。</returns>
        public static long? ToInt64(this string s)
        {
            long value;
            return long.TryParse(s, out value) ? (long?) value : null;
        }

        /// <summary>
        /// 将字符串转换为<c>long</c>类型的值
        /// 源字符串会被当作采用十进制描述数值。
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <param name="defaultValue">用转换失败时返回的默认值</param>
        /// <returns>转换得来的<c>long</c>值。若转换失败返回<c>defaultValue</c></returns>
        public static long ToInt64(this string s, long defaultValue)
        {
            long value;
            return long.TryParse(s, out value) ? value : defaultValue;
        }
    }
}

namespace Viyi.Util
{
    partial class StringUtil
    {
        /// <summary>
        /// 将字符串转换为<c>Nullable&lt;ulong&gt;</c>类型的值
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <param name="style">源字符串描述数字的样式</param>
        /// <returns><c>ulong?</c>值。若转换失败返回null。</returns>
        public static ulong? ToUInt64(this string s, NumberStyles style)
        {
            ulong value;
            return ulong.TryParse(s, style, NumberFormatInfo.CurrentInfo, out value)
                ? (ulong?) value
                : null;
        }

        /// <summary>
        /// 将字符串转换为<c>ulong</c>类型的值
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <param name="style">源字符串描述数字的样式</param>
        /// <param name="defaultValue">用转换失败时返回的默认值</param>
        /// <returns>转换得来的<c>ulong</c>值。若转换失败返回<c>defaultValue</c></returns>
        public static ulong ToUInt64(this string s, NumberStyles style, ulong defaultValue)
        {
            ulong value;
            return ulong.TryParse(s, style, NumberFormatInfo.CurrentInfo, out value)
                ? value
                : defaultValue;
        }

        /// <summary>
        /// 将字符串转换为<c>Nullable&lt;ulong&gt;</c>类型的值。
        /// 源字符串会被当作采用十进制描述数值。
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <returns><c>ulong?</c>值。若转换失败返回null。</returns>
        public static ulong? ToUInt64(this string s)
        {
            ulong value;
            return ulong.TryParse(s, out value) ? (ulong?) value : null;
        }

        /// <summary>
        /// 将字符串转换为<c>ulong</c>类型的值
        /// 源字符串会被当作采用十进制描述数值。
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <param name="defaultValue">用转换失败时返回的默认值</param>
        /// <returns>转换得来的<c>ulong</c>值。若转换失败返回<c>defaultValue</c></returns>
        public static ulong ToUInt64(this string s, ulong defaultValue)
        {
            ulong value;
            return ulong.TryParse(s, out value) ? value : defaultValue;
        }
    }
}

namespace Viyi.Util
{
    partial class StringUtil
    {
        /// <summary>
        /// 将字符串转换为<c>Nullable&lt;byte&gt;</c>类型的值
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <param name="style">源字符串描述数字的样式</param>
        /// <returns><c>byte?</c>值。若转换失败返回null。</returns>
        public static byte? ToByte(this string s, NumberStyles style)
        {
            byte value;
            return byte.TryParse(s, style, NumberFormatInfo.CurrentInfo, out value)
                ? (byte?) value
                : null;
        }

        /// <summary>
        /// 将字符串转换为<c>byte</c>类型的值
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <param name="style">源字符串描述数字的样式</param>
        /// <param name="defaultValue">用转换失败时返回的默认值</param>
        /// <returns>转换得来的<c>byte</c>值。若转换失败返回<c>defaultValue</c></returns>
        public static byte ToByte(this string s, NumberStyles style, byte defaultValue)
        {
            byte value;
            return byte.TryParse(s, style, NumberFormatInfo.CurrentInfo, out value)
                ? value
                : defaultValue;
        }

        /// <summary>
        /// 将字符串转换为<c>Nullable&lt;byte&gt;</c>类型的值。
        /// 源字符串会被当作采用十进制描述数值。
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <returns><c>byte?</c>值。若转换失败返回null。</returns>
        public static byte? ToByte(this string s)
        {
            byte value;
            return byte.TryParse(s, out value) ? (byte?) value : null;
        }

        /// <summary>
        /// 将字符串转换为<c>byte</c>类型的值
        /// 源字符串会被当作采用十进制描述数值。
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <param name="defaultValue">用转换失败时返回的默认值</param>
        /// <returns>转换得来的<c>byte</c>值。若转换失败返回<c>defaultValue</c></returns>
        public static byte ToByte(this string s, byte defaultValue)
        {
            byte value;
            return byte.TryParse(s, out value) ? value : defaultValue;
        }
    }
}

namespace Viyi.Util
{
    partial class StringUtil
    {
        /// <summary>
        /// 将字符串转换为<c>Nullable&lt;sbyte&gt;</c>类型的值
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <param name="style">源字符串描述数字的样式</param>
        /// <returns><c>sbyte?</c>值。若转换失败返回null。</returns>
        public static sbyte? ToSByte(this string s, NumberStyles style)
        {
            sbyte value;
            return sbyte.TryParse(s, style, NumberFormatInfo.CurrentInfo, out value)
                ? (sbyte?) value
                : null;
        }

        /// <summary>
        /// 将字符串转换为<c>sbyte</c>类型的值
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <param name="style">源字符串描述数字的样式</param>
        /// <param name="defaultValue">用转换失败时返回的默认值</param>
        /// <returns>转换得来的<c>sbyte</c>值。若转换失败返回<c>defaultValue</c></returns>
        public static sbyte ToSByte(this string s, NumberStyles style, sbyte defaultValue)
        {
            sbyte value;
            return sbyte.TryParse(s, style, NumberFormatInfo.CurrentInfo, out value)
                ? value
                : defaultValue;
        }

        /// <summary>
        /// 将字符串转换为<c>Nullable&lt;sbyte&gt;</c>类型的值。
        /// 源字符串会被当作采用十进制描述数值。
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <returns><c>sbyte?</c>值。若转换失败返回null。</returns>
        public static sbyte? ToSByte(this string s)
        {
            sbyte value;
            return sbyte.TryParse(s, out value) ? (sbyte?) value : null;
        }

        /// <summary>
        /// 将字符串转换为<c>sbyte</c>类型的值
        /// 源字符串会被当作采用十进制描述数值。
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <param name="defaultValue">用转换失败时返回的默认值</param>
        /// <returns>转换得来的<c>sbyte</c>值。若转换失败返回<c>defaultValue</c></returns>
        public static sbyte ToSByte(this string s, sbyte defaultValue)
        {
            sbyte value;
            return sbyte.TryParse(s, out value) ? value : defaultValue;
        }
    }
}

namespace Viyi.Util
{
    partial class StringUtil
    {
        /// <summary>
        /// 将字符串转换为<c>Nullable&lt;decimal&gt;</c>类型的值
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <param name="style">源字符串描述数字的样式</param>
        /// <returns><c>decimal?</c>值。若转换失败返回null。</returns>
        public static decimal? ToDecimal(this string s, NumberStyles style)
        {
            decimal value;
            return decimal.TryParse(s, style, NumberFormatInfo.CurrentInfo, out value)
                ? (decimal?) value
                : null;
        }

        /// <summary>
        /// 将字符串转换为<c>decimal</c>类型的值
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <param name="style">源字符串描述数字的样式</param>
        /// <param name="defaultValue">用转换失败时返回的默认值</param>
        /// <returns>转换得来的<c>decimal</c>值。若转换失败返回<c>defaultValue</c></returns>
        public static decimal ToDecimal(this string s, NumberStyles style, decimal defaultValue)
        {
            decimal value;
            return decimal.TryParse(s, style, NumberFormatInfo.CurrentInfo, out value)
                ? value
                : defaultValue;
        }

        /// <summary>
        /// 将字符串转换为<c>Nullable&lt;decimal&gt;</c>类型的值。
        /// 源字符串会被当作采用十进制描述数值。
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <returns><c>decimal?</c>值。若转换失败返回null。</returns>
        public static decimal? ToDecimal(this string s)
        {
            decimal value;
            return decimal.TryParse(s, out value) ? (decimal?) value : null;
        }

        /// <summary>
        /// 将字符串转换为<c>decimal</c>类型的值
        /// 源字符串会被当作采用十进制描述数值。
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <param name="defaultValue">用转换失败时返回的默认值</param>
        /// <returns>转换得来的<c>decimal</c>值。若转换失败返回<c>defaultValue</c></returns>
        public static decimal ToDecimal(this string s, decimal defaultValue)
        {
            decimal value;
            return decimal.TryParse(s, out value) ? value : defaultValue;
        }
    }
}

namespace Viyi.Util
{
    partial class StringUtil
    {
        /// <summary>
        /// 将字符串转换为<c>Nullable&lt;float&gt;</c>类型的值
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <param name="style">源字符串描述数字的样式</param>
        /// <returns><c>float?</c>值。若转换失败返回null。</returns>
        public static float? ToFloat(this string s, NumberStyles style)
        {
            float value;
            return float.TryParse(s, style, NumberFormatInfo.CurrentInfo, out value)
                ? (float?) value
                : null;
        }

        /// <summary>
        /// 将字符串转换为<c>float</c>类型的值
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <param name="style">源字符串描述数字的样式</param>
        /// <param name="defaultValue">用转换失败时返回的默认值</param>
        /// <returns>转换得来的<c>float</c>值。若转换失败返回<c>defaultValue</c></returns>
        public static float ToFloat(this string s, NumberStyles style, float defaultValue)
        {
            float value;
            return float.TryParse(s, style, NumberFormatInfo.CurrentInfo, out value)
                ? value
                : defaultValue;
        }

        /// <summary>
        /// 将字符串转换为<c>Nullable&lt;float&gt;</c>类型的值。
        /// 源字符串会被当作采用十进制描述数值。
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <returns><c>float?</c>值。若转换失败返回null。</returns>
        public static float? ToFloat(this string s)
        {
            float value;
            return float.TryParse(s, out value) ? (float?) value : null;
        }

        /// <summary>
        /// 将字符串转换为<c>float</c>类型的值
        /// 源字符串会被当作采用十进制描述数值。
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <param name="defaultValue">用转换失败时返回的默认值</param>
        /// <returns>转换得来的<c>float</c>值。若转换失败返回<c>defaultValue</c></returns>
        public static float ToFloat(this string s, float defaultValue)
        {
            float value;
            return float.TryParse(s, out value) ? value : defaultValue;
        }
    }
}

namespace Viyi.Util
{
    partial class StringUtil
    {
        /// <summary>
        /// 将字符串转换为<c>Nullable&lt;double&gt;</c>类型的值
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <param name="style">源字符串描述数字的样式</param>
        /// <returns><c>double?</c>值。若转换失败返回null。</returns>
        public static double? ToDouble(this string s, NumberStyles style)
        {
            double value;
            return double.TryParse(s, style, NumberFormatInfo.CurrentInfo, out value)
                ? (double?) value
                : null;
        }

        /// <summary>
        /// 将字符串转换为<c>double</c>类型的值
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <param name="style">源字符串描述数字的样式</param>
        /// <param name="defaultValue">用转换失败时返回的默认值</param>
        /// <returns>转换得来的<c>double</c>值。若转换失败返回<c>defaultValue</c></returns>
        public static double ToDouble(this string s, NumberStyles style, double defaultValue)
        {
            double value;
            return double.TryParse(s, style, NumberFormatInfo.CurrentInfo, out value)
                ? value
                : defaultValue;
        }

        /// <summary>
        /// 将字符串转换为<c>Nullable&lt;double&gt;</c>类型的值。
        /// 源字符串会被当作采用十进制描述数值。
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <returns><c>double?</c>值。若转换失败返回null。</returns>
        public static double? ToDouble(this string s)
        {
            double value;
            return double.TryParse(s, out value) ? (double?) value : null;
        }

        /// <summary>
        /// 将字符串转换为<c>double</c>类型的值
        /// 源字符串会被当作采用十进制描述数值。
        /// </summary>
        /// <param name="s">源字符串</param>
        /// <param name="defaultValue">用转换失败时返回的默认值</param>
        /// <returns>转换得来的<c>double</c>值。若转换失败返回<c>defaultValue</c></returns>
        public static double ToDouble(this string s, double defaultValue)
        {
            double value;
            return double.TryParse(s, out value) ? value : defaultValue;
        }
    }
}

